'use strict'

const http = require('http')
// const { buffer } = require('stream/consumers')
const fs  = require('fs')


/**------------------------------解析body数据------------------------------*/

/**
 * Content-Disposition: form-data; name="file"; filename="xxx"
 * Content-Type: text/plain
 * @param {string} headerData
 * 
 */
function parseBodyHeaders(headerData) {
    let hlist = headerData.split('\r\n').filter(p => p.length >0)

    //解析content-disposition => hlist[0]
    //按照 ； 切分数组，选出从第二个元素开始的数组
    let csplit = hlist[0].split('; ').slice(1)

    let filename
    let name
    for(let a of csplit) {
        if(a.indexOf('filename=') === 0){
            filename =  a.substring(a.indexOf('=')+2, a.length-1)
        } else {
            name = a.substring(a.indexOf('=')+2, a.length-1)
        }
    }


    let headers = {}
    let ind = 0
    let k
    for (let h of hlist){
        ind = h.indexOf(':')
        k = h.substring(0, ind).toLowerCase
        headers[k] = h.substring(ind+1).trim()
    }
    return {
        filename,
        name,
        headers,
        contentType: headers['content-type'] || ''
    }

}

function parseBody(bodyData, headers){
    let ctype = headers['content-type']
    let bdy = ctype.substring(ctype.indexOf('=') + 1)
    let crlf_bdy = `\f\n--${bdy}`
    let header_end_index = bodyData.indexOf('\r\n\r\n', crlf_bdy.length);
    let headerData = bodyData.toString('utf-8',crlf_bdy.length, header_end_index);

    //解析头文件信息
    let hd = parseBodyHeaders(headerData)
    let file = {
        start:header_end_index + 4,
        end:bodyData.indexOf(crlf_bdy, header_end_index),
        ...hd
    }
    file.length = file.end - file.start
    return file
}
/**--------------------------解析Body数据 -- END ------------------------- */

let html = `
    <!DOCTYPE html>
    <html>
        <head>
            <title>First HTTP</title>
        </head>
        <body>
            你好
        </body>
    <html> `
    let routerTable ={
    GET: {
        '/':async(request,response)=>{
            response.setHeader('content-type', 'text/html; charset=utf-8')
            response.end(html)

        },
        '/test':async(request,response)=>{
            let status =parseInt(Math.random() * 200) +199
            response.statusCode = status
            response.end('test end')
        },
        '/upload':async(request,response)=>{
            let stm = fs.createReadStream('./upload.html')
            stm.pipe(response,{end:false})
            stm.on('end',()=>{
                response.end()
            })
        }
    },

    POST :{
        '/data':async(request,response)=>{
            let bufferLength=0
            let bufferList =[]
            request.on('data',chunk => {
                bufferLength += chunk.length
                bufferList.push(chunk)
            })
            
            let bodyData = null
            request.on('end',()=>{
                if(bufferList.length>0){
                    bodyData = Buffer.concat(bufferList,bufferLength)
                    bufferList=[]
                }

                let file = parseBody(bodyData,request.headers)
                console.log(file)
 
                //parseBody(bodyData, request.headers)

                if(bodyData) {
                    response.end(bodyData)
                }else{
                    response.end()
                }
        
            })
        }
    }
}
http.createServer((request, response) => {
    
    let rm = routerTable[request.method]

    if(!rm || !rm[request.url]){
        response.statusCode = 404
        response.end('page not found')
        return
    }
    rm[ request.url ](request,response)
})
  

.listen(3456)
/***
 * .jpg .jpeg  --> image/jpeg
 * .png -->image/png
 * .gif ---> image/gif
 * .ico ===>image/x-icon
 * .txt ->text/plain
 * .json ->text/json 或application/json
 * .xml  -->text/xml 或 application/xml
 */